import bean.*;

import java.util.Arrays;

/**
 * 方法的引用
 */
public class Demo02MethodReference {
    public static void main(String[] args) {

//       objectMethodReference();      //通过对象名引用成员方法
//       staticMethodReference();      //通过类名引用静态成员方法
//       new Man().show();             //用super/this引用父类/子类的成员方法(看Man.java)
//       constructorMethodReference(); //类的构造器引用
//       arrayMethodReference();       //数组的构造器引用
    }

    /**
     * 数组的构造器引用
     */
    private static void arrayMethodReference() {
        //调用createArray方法,传递数组的长度和Lambda表达式
        int[] arr1 = createArray(10,(len)->{
            //根据数组的长度,创建数组并返回
            return new int[len];
        });
        System.out.println(arr1.length);//10

        /*
            使用方法引用优化Lambda表达式
            已知创建的就是int[]数组
            数组的长度也是已知的
            就可以使用方法引用
            int[]引用new,根据参数传递的长度来创建数组
         */
        int[] arr2 =createArray(10,int[]::new);
        System.out.println(Arrays.toString(arr2));
        System.out.println(arr2.length);//10
    }

    //定义一个方法,方法的参数传递创建数组的长度和ArrayBuilder接口,
    //      内部使用ArrayBuilder中的方法创建数组并返回
    public static int[] createArray(int length, ArrayBuilder ab){
        return ab.builderArray(length);
    }

    /**
     * 类的构造器(构造方法)引用
     */
    private static void constructorMethodReference() {
        //调用printName方法,方法的参数PersonBuilder接口是一个函数式接口,可以传递Lambda
        printName("迪丽热巴",(String name)->{
            return new Person(name);
        });
        /*
            使用方法引用优化Lambda表达式
            构造方法new Person(String name) 已知
            创建对象已知 new
            就可以使用Person引用new创建对象
         */
        printName("古力娜扎",Person::new);//使用Person类的带参构造方法,通过传递的姓名创建对象
    }

    //定义一个方法,参数传递姓名和PersonBuilder接口,方法中通过姓名创建Person对象
    public static void printName(String name,PersonBuilder pb){
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    /**
     * 通过类名引用静态成员方法
     * 类已经存在,静态成员方法也已经存在
     * 就可以通过类名直接引用静态成员方法
     */
    private static void staticMethodReference() {
        //调用method方法,传递计算绝对值得整数,和Lambda表达式
        int number = method(-10,(n)->{
            //对参数进行绝对值得计算并返回结果
            return Math.abs(n);
        });
        System.out.println(number);
        /**
            使用方法引用优化Lambda表达式
            Math类是存在的
            abs计算绝对值的静态方法也是已经存在的
            所以我们可以直接通过类名引用静态方法
         */
        int number2 = method(-10,Math::abs);
        System.out.println(number2);
    }

    //定义一个方法,方法的参数传递要计算绝对值的整数,和函数式接口Calcable
    public static int method(int number, Calcable c){
        return c.calsAbs(number);
    }

    /**
     * 通过对象名引用成员方法
     * 使用前提是对象名是已经存在的,成员方法也是已经存在
     * 就可以使用对象名来引用成员方法
     */
    private static void objectMethodReference() {
        //调用printString方法,方法的参数Printable是一个函数式接口,所以可以传递Lambda表达式
        printString((s)->{  //s代表传递过来的字符串(Hello)
            //创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();
            //调用MethodRerObject对象中的成员方法printUpperCaseString,把字符串按照大写输出
            obj.printUpperCaseString(s);
        });
        /**
            使用方法引用优化Lambda
            MethodRerObject 对象是已经存在的
            printUpperCaseString 方法也是已经存在的
            所以我们可以优化Lambda表达式,使用对象名引用成员方法
         */
        //创建MethodRerObject对象
        MethodRerObject obj = new MethodRerObject();
        printString(obj::printUpperCaseString);
    }

    //定义一个方法,方法的参数传递Printable接口
    public static void printString(Printable p){
        p.print("Hello");
    }


}
